/*  _______         ____    __         ___    ___
 * \    _  \       \    /  \  /       \   \  /   /       '   '  '
 *  |  | \  \       |  |    ||         |   \/   |         .      .
 *  |  |  |  |      |  |    ||         ||\  /|  |
 *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '
 *  |  |  |  |      |  |    ||         ||    |  |         .      .
 *  |  |_/  /        \  \__//          ||    |  |
 * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque
 *                                                      /  \
 *                                                     / .  \
 * readmtm.c - Code to read a MultiTracker Module     / / \  \
 *             from an open file.                    | <  /   \_
 *                                                   |  \/ /\   /
 * By Christopher Snowhill.                           \_  /  > /
 *                                                      | \ / /
 *                                                      |  ' /
 *                                                       \__/
 */

#include <stdlib.h>
#include <string.h>
#include <math.h>

#include "dumb.h"
#include "internal/it.h"

size_t strlen_max(const char *ptr, size_t max) {
    const char *end, *start;
    if (ptr == 0)
        return 0;
    start = ptr;
    end = ptr + max;
    while (ptr < end && *ptr)
        ptr++;
    return ptr - start;
}

static int it_mtm_assemble_pattern(IT_PATTERN *pattern,
                                   const unsigned char *track,
                                   const unsigned short *sequence, int n_rows) {
    int n, o, note, sample;
    const unsigned char *t;
    IT_ENTRY *entry;

    pattern->n_rows = n_rows;
    pattern->n_entries = n_rows;

    for (n = 0; n < 32; n++) {
        if (sequence[n]) {
            t = &track[192 * (sequence[n] - 1)];
            for (o = 0; o < n_rows; o++) {
                if (t[0] || t[1] || t[2])
                    pattern->n_entries++;
                t += 3;
            }
        }
    }

    entry = malloc(pattern->n_entries * sizeof(*entry));
    if (!entry)
        return -1;
    pattern->entry = entry;

    for (n = 0; n < n_rows; n++) {
        for (o = 0; o < 32; o++) {
            if (sequence[o]) {
                t = &track[192 * (sequence[o] - 1) + (n * 3)];
                if (t[0] || t[1] || t[2]) {
                    entry->channel = o;
                    entry->mask = 0;
                    note = t[0] >> 2;
                    sample = ((t[0] << 4) | (t[1] >> 4)) & 0x3F;

                    if (note) {
                        entry->mask |= IT_ENTRY_NOTE;
                        entry->note = note + 24;
                    }

                    if (sample) {
                        entry->mask |= IT_ENTRY_INSTRUMENT;
                        entry->instrument = sample;
                    }

                    _dumb_it_xm_convert_effect(t[1] & 0xF, t[2], entry, 1);

                    if (entry->mask)
                        entry++;
                }
            }
        }
        IT_SET_END_ROW(entry);
        entry++;
    }

    pattern->n_entries = (int)(entry - pattern->entry);

    return 0;
}

static int it_mtm_read_sample_header(IT_SAMPLE *sample, DUMBFILE *f,
                                     int *skip_bytes) {
    int finetune, flags;

    dumbfile_getnc((char *)sample->name, 22, f);
    sample->name[22] = 0;

    sample->filename[0] = 0;

    sample->length = dumbfile_igetl(f);
    sample->loop_start = dumbfile_igetl(f);
    sample->loop_end = dumbfile_igetl(f);
    finetune = (signed char)(dumbfile_getc(f) << 4) >> 4; /* signed nibble */
    sample->global_volume = 64;
    sample->default_volume = dumbfile_getc(f);

    flags = dumbfile_getc(f);

    if (sample->length <= 0) {
        sample->flags = 0;
        return 0;
    }

    sample->flags = IT_SAMPLE_EXISTS;

    *skip_bytes = 0;
    if (flags & 1) {
        *skip_bytes = sample->length & 1;
        sample->flags |= IT_SAMPLE_16BIT;
        sample->length >>= 1;
        sample->loop_start >>= 1;
        sample->loop_end >>= 1;
    }

    sample->default_pan = 0;
    sample->C5_speed =
        (int)(AMIGA_CLOCK /
              214.0); //(long)(16726.0*pow(DUMB_PITCH_BASE, finetune*32));
    sample->finetune = finetune * 32;
    // the above line might be wrong

    if (sample->loop_end > sample->length)
        sample->loop_end = sample->length;

    if (sample->loop_end - sample->loop_start > 2)
        sample->flags |= IT_SAMPLE_LOOP;

    sample->vibrato_speed = 0;
    sample->vibrato_depth = 0;
    sample->vibrato_rate = 0;
    sample->vibrato_waveform = 0; // do we have to set _all_ these?
    sample->max_resampling_quality = -1;

    return dumbfile_error(f);
}

static int it_mtm_read_sample_data(IT_SAMPLE *sample, DUMBFILE *f,
                                   int skip_bytes) {
    long i;
    long truncated_size;
    long bytes_per_sample;

    /* let's get rid of the sample data coming after the end of the loop */
    if ((sample->flags & IT_SAMPLE_LOOP) && sample->loop_end < sample->length) {
        truncated_size = sample->length - sample->loop_end;
        sample->length = sample->loop_end;
    } else {
        truncated_size = 0;
    }

    bytes_per_sample = (sample->flags & IT_SAMPLE_16BIT) ? 2 : 1;

    sample->data = malloc(sample->length * bytes_per_sample);

    if (!sample->data)
        return -1;

    dumbfile_getnc((char *)sample->data, sample->length * bytes_per_sample, f);
    dumbfile_skip(f, truncated_size * bytes_per_sample);
    dumbfile_skip(f, skip_bytes);

    if (dumbfile_error(f))
        return -1;

    if (bytes_per_sample == 1)
        for (i = 0; i < sample->length; i++)
            ((signed char *)sample->data)[i] ^= 0x80;

    return 0;
}

static DUMB_IT_SIGDATA *it_mtm_load_sigdata(DUMBFILE *f, int *version) {
    DUMB_IT_SIGDATA *sigdata;

    int n, o, n_tracks, l_comment, n_rows, n_channels;

    unsigned char *track;

    unsigned short *sequence;

    char *comment;

    int *skip_bytes;

    if (dumbfile_getc(f) != 'M' || dumbfile_getc(f) != 'T' ||
        dumbfile_getc(f) != 'M')
        goto error;

    *version = dumbfile_getc(f);

    sigdata = malloc(sizeof(*sigdata));
    if (!sigdata)
        goto error;

    dumbfile_getnc((char *)sigdata->name, 20, f);
    sigdata->name[20] = 0;

    n_tracks = dumbfile_igetw(f);
    sigdata->n_patterns = dumbfile_getc(f) + 1;
    sigdata->n_orders = dumbfile_getc(f) + 1;
    l_comment = dumbfile_igetw(f);
    sigdata->n_samples = dumbfile_getc(f);
    // if (dumbfile_getc(f)) goto error_sd;
    dumbfile_getc(f);
    n_rows = dumbfile_getc(f);
    n_channels = dumbfile_getc(f);

    if (dumbfile_error(f) || (n_tracks <= 0) || (sigdata->n_samples <= 0) ||
        (n_rows <= 0 || n_rows > 64) || (n_channels <= 0 || n_channels > 32))
        goto error_sd;

    memset(sigdata->channel_volume, 64, DUMB_IT_N_CHANNELS);

    if (dumbfile_getnc((char *)sigdata->channel_pan, 32, f) < 32)
        goto error_sd;

    for (n = 0; n < 32; n++) {
        if (sigdata->channel_pan[n] <= 15) {
            sigdata->channel_pan[n] -= (sigdata->channel_pan[n] & 8) >> 3;
            sigdata->channel_pan[n] = (sigdata->channel_pan[n] * 32) / 7;
        } else {
            sigdata->channel_volume[n] = 0;
            sigdata->channel_pan[n] = 7;
        }
    }

    for (n = 32; n < DUMB_IT_N_CHANNELS; n += 4) {
        int sep = 32 * dumb_it_default_panning_separation / 100;
        sigdata->channel_pan[n] = 32 - sep;
        sigdata->channel_pan[n + 1] = 32 + sep;
        sigdata->channel_pan[n + 2] = 32 + sep;
        sigdata->channel_pan[n + 3] = 32 - sep;
    }

    sigdata->sample = malloc(sigdata->n_samples * sizeof(*sigdata->sample));
    if (!sigdata->sample)
        goto error_sd;

    sigdata->flags = IT_WAS_AN_XM | IT_WAS_A_MOD | IT_STEREO | IT_OLD_EFFECTS |
                     IT_COMPATIBLE_GXX;

    sigdata->global_volume = 128;
    sigdata->mixing_volume = 48;
    sigdata->speed = 6;
    sigdata->tempo = 125;
    sigdata->pan_separation = 128;

    sigdata->song_message = NULL;
    sigdata->order = NULL;
    sigdata->instrument = NULL;
    sigdata->pattern = NULL;
    sigdata->midi = NULL;
    sigdata->checkpoint = NULL;

    sigdata->n_instruments = 0;

    sigdata->restart_position = 0;
    sigdata->n_pchannels = n_channels;

    for (n = 0; n < sigdata->n_samples; n++)
        sigdata->sample[n].data = NULL;

    skip_bytes = calloc(sizeof(int), sigdata->n_samples);
    if (!skip_bytes)
        goto error_usd;

    for (n = 0; n < sigdata->n_samples; n++) {
        if (it_mtm_read_sample_header(&sigdata->sample[n], f, skip_bytes + n))
            goto error_sb;
    }

    sigdata->order = malloc(sigdata->n_orders);
    if (!sigdata->order)
        goto error_sb;

    if (dumbfile_getnc((char *)sigdata->order, sigdata->n_orders, f) <
        sigdata->n_orders)
        goto error_sb;
    if (sigdata->n_orders < 128)
        if (dumbfile_skip(f, 128 - sigdata->n_orders))
            goto error_sb;

    track = malloc(192 * n_tracks);
    if (!track)
        goto error_sb;

    if (dumbfile_getnc((char *)track, 192 * n_tracks, f) < 192 * n_tracks)
        goto error_ft;

    sigdata->pattern = malloc(sigdata->n_patterns * sizeof(*sigdata->pattern));
    if (!sigdata->pattern)
        goto error_ft;
    for (n = 0; n < sigdata->n_patterns; n++)
        sigdata->pattern[n].entry = NULL;

    sequence = malloc(sigdata->n_patterns * 32 * sizeof(*sequence));
    if (!sequence)
        goto error_ft;

    for (n = 0; n < sigdata->n_patterns; n++) {
        for (o = 0; o < 32; o++) {
            sequence[(n * 32) + o] = dumbfile_igetw(f);
            if (sequence[(n * 32) + o] > n_tracks) {
                // goto error_fs;
                // illegal track number, silence instead of rejecting the file
                sequence[(n * 32) + o] = 0;
            }
        }
    }

    for (n = 0; n < sigdata->n_patterns; n++) {
        if (it_mtm_assemble_pattern(&sigdata->pattern[n], track,
                                    &sequence[n * 32], n_rows))
            goto error_fs;
    }

    if (l_comment) {
        comment = malloc(l_comment);
        if (!comment)
            goto error_fs;
        if (dumbfile_getnc(comment, l_comment, f) < l_comment)
            goto error_fc;

        /* Time for annoying "logic", yes. We want each line which has text,
         * and each blank line in between all the valid lines.
         */

        /* Find last actual line. */
        for (o = -1, n = 0; n < l_comment; n += 40) {
            if (comment[n])
                o = n;
        }

        if (o >= 0) {

            int l, m;

            for (l = 0, n = 0; n <= o; n += 40) {
                int maxlen = l_comment - n;
                l += strlen_max(&comment[n], maxlen > 40 ? 40 : maxlen) + 2;
            }

            l -= 1;

            sigdata->song_message = malloc(l);
            if (!sigdata->song_message)
                goto error_fc;

            for (m = 0, n = 0; n <= o; n += 40) {
                int maxlen = l_comment - n;
                int p = (int)strlen_max(&comment[n], maxlen > 40 ? 40 : maxlen);
                if (p) {
                    memcpy(sigdata->song_message + m, &comment[n], p);
                    m += p;
                }
                if (l - m > 1) {
                    sigdata->song_message[m++] = 13;
                    sigdata->song_message[m++] = 10;
                }
            }

            sigdata->song_message[m] = 0;
        }

        free(comment);
    }

    for (n = 0; n < sigdata->n_samples; n++) {
        if (it_mtm_read_sample_data(&sigdata->sample[n], f, skip_bytes[n]))
            goto error_fs;
    }

    free(sequence);
    free(track);
    free(skip_bytes);

    if (_dumb_it_fix_invalid_orders(sigdata) < 0) {
        _dumb_it_unload_sigdata(sigdata);
        return NULL;
    }

    return sigdata;

error_fc:
    free(comment);
error_fs:
    free(sequence);
error_ft:
    free(track);
error_sb:
    free(skip_bytes);
error_usd:
    _dumb_it_unload_sigdata(sigdata);
    return NULL;

error_sd:
    free(sigdata);
error:
    return NULL;
}

static char hexdigit(int in) {
    if (in < 10)
        return in + '0';
    else
        return in + 'A' - 10;
}

DUH *dumb_read_mtm_quick(DUMBFILE *f) {
    sigdata_t *sigdata;
    int ver;

    DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it;

    sigdata = it_mtm_load_sigdata(f, &ver);

    if (!sigdata)
        return NULL;

    {
        char version[16];
        const char *tag[2][2];
        tag[0][0] = "TITLE";
        tag[0][1] = (const char *)(((DUMB_IT_SIGDATA *)sigdata)->name);
        tag[1][0] = "FORMAT";
        version[0] = 'M';
        version[1] = 'T';
        version[2] = 'M';
        version[3] = ' ';
        version[4] = 'v';
        version[5] = hexdigit(ver >> 4);
        version[6] = '.';
        version[7] = hexdigit(ver & 15);
        version[8] = 0;
        tag[1][1] = (const char *)&version;
        return make_duh(-1, 2, (const char *const(*)[2])tag, 1, &descptr,
                        &sigdata);
    }
}
